{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 信息熵（熵越高，数据越混乱）\n",
    "\n",
    "$$\n",
    "H=-\\sum _{i=1}^{n} p(x_i) \\log_2 p(x_i)\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code: 3-1\n",
    "from math import log  # 导入对数\n",
    "\n",
    "def calc_shannon_ent(dataset):\n",
    "    \"\"\"\n",
    "    计算信息增益\n",
    "    :param dataset: 数据集\n",
    "    :return : 信息熵\n",
    "    \"\"\"\n",
    "    num = len(dataset)\n",
    "    lab_num = {}\n",
    "    # 为所有分类创建字典\n",
    "    for feat in dataset:\n",
    "        label = feat[-1]\n",
    "        if label not in lab_num.keys():\n",
    "            lab_num[label] = 0\n",
    "        lab_num[label] += 1\n",
    "    \n",
    "    # 计算信息熵\n",
    "    shannon_ent = 0.0\n",
    "    for key in lab_num:\n",
    "        prob = float(lab_num[key])/num\n",
    "        shannon_ent -= prob * log(prob, 2)\n",
    "    return shannon_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataset():\n",
    "    dataset = [\n",
    "        [1, 1, 'yes'],\n",
    "        [1, 1, 'yes'],\n",
    "        [1, 0, 'no'],\n",
    "        [0, 1, 'no'],\n",
    "        [0, 1, 'no'],\n",
    "    ]\n",
    "    lables = ['no surfacing', 'flippers']\n",
    "    return dataset, lables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]\n",
      "['no surfacing', 'flippers']\n"
     ]
    }
   ],
   "source": [
    "my_data, labels = create_dataset()\n",
    "print(my_data)\n",
    "print(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_shannon_ent(my_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 1, 'maybe'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_data[0][-1] = 'maybe'\n",
    "my_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.3709505944546687"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_shannon_ent(my_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code: 3-2\n",
    "\n",
    "def splite_data(dataset, axis, value):\n",
    "    \"\"\"\n",
    "    分割数据\n",
    "    :param dataset: 要分割的数据集\n",
    "    :param axis: 维度，会删掉axis维的数据\n",
    "    :param value: 该维度对应的值\n",
    "    :return : 信息熵\n",
    "    \"\"\"\n",
    "    res = []  # 创建的新的list对象\n",
    "    for data in dataset:\n",
    "        if data[axis] == value:\n",
    "            # 跳过第i个属性值\n",
    "            reduced_dataset = data[:axis]\n",
    "            reduced_dataset.extend(data[axis + 1:])  # 追加\n",
    "            res.append(reduced_dataset)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 1, 'maybe'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 函数测试\n",
    "my_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'maybe'], [1, 'yes'], [0, 'no'], [0, 'no']]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splite_data(my_data, 1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code: 3-3\n",
    "\n",
    "def choose_best_feat(dataset):\n",
    "    \"\"\"\n",
    "    选择最好的分割属性\n",
    "    :param dataset: 要分割的数据集\n",
    "    :return : 属性i\n",
    "    \"\"\"\n",
    "    feat_num = len(dataset[0]) - 1  # 特征数量\n",
    "    base_entropy = calc_shannon_ent(dataset)\n",
    "    best_info_gain = 0.0\n",
    "    best_feature = -1\n",
    "    for i in range(feat_num):\n",
    "        # 创建第i个特征的列表\n",
    "        feat_list = [example[i] for example in dataset]\n",
    "        unique_vals = set(feat_list)  # 去掉重复值\n",
    "        \n",
    "        # 计算每种划分方式的信息熵\n",
    "        new_entroy = 0.0\n",
    "        for val in unique_vals:\n",
    "            subdata = splite_data(dataset, i, val)\n",
    "            prob = len(subdata)/float(len(dataset))\n",
    "            new_entroy += prob * calc_shannon_ent(subdata)\n",
    "        info_gain = base_entropy - new_entroy\n",
    "        \n",
    "        # 计算最好的信息熵\n",
    "        if info_gain > best_info_gain:\n",
    "            best_info_gain = info_gain\n",
    "            best_feature = i\n",
    "    return best_feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 1, 'maybe'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "choose_best_feat(my_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "\n",
    "def majority_cnt(class_list):\n",
    "    \"\"\"\n",
    "    获取类别最多的类标记\n",
    "    :param class_list: 类别列表\n",
    "    :return : 类别最多的类标记\n",
    "    \"\"\"\n",
    "    class_count = {}\n",
    "    for vote in class_list:\n",
    "        if vote not in class_count.keys():\n",
    "            class_count[vote] = 0\n",
    "        class_count[vote] += 1\n",
    "    sorted_class_count = sorted(class_count.iteritems(), key=operator.itemgetter(1), reverse=True)\n",
    "    return sorted_class_count[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code: 3-4\n",
    "\n",
    "def create_tree(dataset, labels):\n",
    "    \"\"\"\n",
    "    创建树\n",
    "    :param dataset: 数据集\n",
    "    :param labels: 标签列表，包含在dataset中，但为了给出数据明确的含义，将他作为一个输入参数提供\n",
    "    :return : \n",
    "    \"\"\"\n",
    "    class_list = [example[-1] for example in dataset]\n",
    "    \n",
    "    # 停止条件：所有的类标签完全相同\n",
    "    if class_list.count(class_list[0]) == len(class_list):\n",
    "        return class_list[0]\n",
    "    \n",
    "    # 停止条件：使用完所有特征，仍不能将数据集正确划分\n",
    "    if len(dataset[0]) == 1:\n",
    "        return majority_cnt(class_list)\n",
    "    \n",
    "    best_feat = choose_best_feat(dataset)\n",
    "    best_feat_label = labels[best_feat]\n",
    "    my_tree = {best_feat_label:{}}\n",
    "    \n",
    "    # 得到列表包含的所有属性值\n",
    "    del(labels[best_feat])\n",
    "    feat_val = [example[best_feat] for example in dataset]\n",
    "    unique_val = set(feat_val)\n",
    "    \n",
    "    for val in unique_val:\n",
    "        sub_labels = labels[:]\n",
    "        my_tree[best_feat_label][val] = create_tree(splite_data(dataset, best_feat, val), sub_labels)\n",
    "        \n",
    "    return my_tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myTree:  {'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "my_data, labels = create_dataset()\n",
    "myTree = create_tree(my_data, labels)\n",
    "print('myTree: ', myTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code:3-8\n",
    "def classify(inputTree, featLabels, testVec):\n",
    "    \"\"\"\n",
    "    决策树的分类函数\n",
    "    \"\"\"\n",
    "    first_str = list(inputTree.keys())[0]\n",
    "    # {'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}\n",
    "    second_dict = inputTree[first_str]\n",
    "    featIndex = featLabels.index(first_str) # 标签字符串转换为索引\n",
    "    for key in second_dict.keys():`\n",
    "        if testVec[featIndex] == key:\n",
    "            if type(second_dict[key]).__name__=='dict':\n",
    "                classLabel = classify(second_dict[key], featLabels, testVec)\n",
    "            else:\n",
    "                classLabel = second_dict[key]\n",
    "    return classLabel\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['no surfacing', 'flippers']\n",
      "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}\n",
      "no\n",
      "yes\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "import treePlotter\n",
    "my_data, labels = create_dataset()\n",
    "print(labels)\n",
    "myTree = treePlotter.retrieve_tree(0)\n",
    "print(myTree)\n",
    "print(classify(myTree, labels, [1,0]))\n",
    "print(classify(myTree, labels, [1,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code 3-9\n",
    "def storge_tree(input_tree, file_name):\n",
    "    import pickle\n",
    "    fw = open(file_name, 'wb')\n",
    "    pickle.dump(input_tree, fw)\n",
    "    fw.close()\n",
    "\n",
    "def grab_tree(file_name):\n",
    "    import pickle\n",
    "    fr = open(file_name, 'rb')\n",
    "    return pickle.load(fr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "storge_tree(myTree, 'ClassifierStorge.txt')\n",
    "grab_tree('ClassifierStorge.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'tearRate': {'normal': {'astigmatic': {'yes': {'prescript': {'hyper': {'age': {'pre': 'no lenses',\n",
       "        'young': 'hard',\n",
       "        'presbyopic': 'no lenses'}},\n",
       "      'myope': 'hard'}},\n",
       "    'no': {'age': {'pre': 'soft',\n",
       "      'young': 'soft',\n",
       "      'presbyopic': {'prescript': {'hyper': 'soft', 'myope': 'no lenses'}}}}}},\n",
       "  'reduced': 'no lenses'}}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fr = open('./dataset/lenses.txt')\n",
    "lenses = [inst.strip().split('\\t') for inst in fr.readlines()]\n",
    "lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']\n",
    "lensesTree = create_tree(lenses, lensesLabels)\n",
    "lensesTree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "treePlotter.create_plot(lensesTree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
